Low-density parity-check (LDPC) codes constitute a class of iteratively decoded error-control codes whose capacity-approaching performance and simple decoding have resulted in their inclusion in new communications standards such as DVB-S2, IEEE 802.11n, 802.3an, and 802.16. The basis of conventional LDPC codes are described in S. Lin and D. J. Costello, Error Control Coding. Prentice-Hall, 2nd Edition, 2004. The LDPC codes are iteratively decoded using a message-passing algorithm operating between variable and check nodes. The conventional decoder for binary LDPC codes uses the “logarithm a posteriori probability ratio” (LAPPR), which is the same as the log-likelihood ratio (LLR) when 1 and −1 are transmitted with equal probability 1/2, as a message. With this approach, the calculation of a hyperbolic tangent function is required at check nodes for the conventional LAPPR message. From the hardware implementation point of view, a look-up table to calculate a hyperbolic tangent function is needed.
An example structure of a decoder for sum-product decoding of LDPC codes is shown in FIG. 1. Shown are a set of variable nodes 10 and a set of check nodes 12. Arrows interconnecting the variable nodes and the check nodes represent message passing that takes place. An arrow 14 from a variable node 10 to a check node 12 represents a message generated by the variable node that is passed to the check node 12. An arrow 16 from a check node 12 to a variable node 10 represents a message generated by the check node 12 that is passed to the variable node 10. The set of variable nodes 10 passing messages to a given check node 12 are the neighbours of the check node 12. A variable node 10 of degree dv has dv neighbours. Similarly, the set of check nodes 12 passing messages to a given variable node 10 are the neighbours of that variable node 10. A check node 12 of degree dc has dc neighbours. Also shown is a set of intrinsic inputs 18 to the variable nodes 10 that are used to define an initial state of the decoder.
In a conventional LDPC decoder, the message output by a variable node v for a check node is referred to as a LAPPR mv→c output message. The message output by a check node c is referred to as a LAPPR mc→v output message.
The LAPPR mv→c output message of a given variable node v is given by
                              m                      v            →            c                          =                              m            0                    +                                    ∑                              h                ∈                                                      n                    v                                    -                                      {                    c                    }                                                                        ⁢                          m                              h                →                v                                                                        (        1        )            where m0, is the intrinsic message for variable node v, mh→v is the LAPPR message sent from check node h to variable node v, and nv−{c} represents the set of all the neighbors of node v in the graph that send check node messages to node v. Thus, the LAPPR message at a variable node is the sum of the incoming LAPPR messages. For binary phase shift keying (BPSK) signaling over an additive white Gaussian noise (AWGN) channel, the intrinsic message m0 is given by
                              m          0                =                              ln            ⁢                                          ⅇ                                  -                                                                                    (                                                  r                          -                          1                                                )                                            2                                                              2                      ⁢                                              σ                        2                                                                                                                        ⅇ                                  -                                                                                    (                                                  r                          +                          1                                                )                                            2                                                              2                      ⁢                                              σ                        2                                                                                                                          =                                    2              ⁢              r                                      σ              2                                                          (        2        )            where r is the matched filter output and σ2 is the noise variance. If the variable node message is represented using APPR, (1) can be written as
                              APPR                      v            →            c                          =                              APPR            0                    ⁢                                    ∏                              h                ∈                                                      n                    v                                    -                                      {                    c                    }                                                                        ⁢                                                  ⁢                          APPR                              h                →                v                                                                        (        3        )            where APPR0 is equal to em0.
The conventional LAPPR mc→v output message of a given check node c is given by
                              m                      c            →            v                          =                  2          ⁢                                          ⁢                                    tanh                              -                1                                      ⁡                          (                                                ∏                                      y                    ∈                                                                  n                        c                                            -                                              {                        v                        }                                                                                            ⁢                                  tanh                  ⁡                                      (                                                                  m                                                  y                          →                          c                                                                    2                                        )                                                              )                                                          (        4        )            where nc−{v} represents the set of all the neighbors of a node c in the graph that send variable node messages to node c.
It is shown in T. Richardson and R. Urbanke, Modern Coding Theory. “http://lthcwww.epfl.ch/mct/index.php that Eq. (4) can be written as
                              tanh          ⁡                      (                                          m                                  c                  →                  v                                            2                        )                          =                              ∏                          y              ∈                                                n                  c                                -                                  {                  v                  }                                                              ⁢                                    tanh              ⁡                              (                                                      m                                          y                      →                      c                                                        2                                )                                      .                                              (        5        )            
Assuming p and q are a posteriori probabilities, the LAPPR message m can be written as
                    m        =                  ln          ⁢                      p            q                                              (        6        )            where p+q=1.
After some manipulation, it can be shown that
                              tanh          ⁡                      (                          m              2                        )                          =                                                            ⅇ                m                                            1                +                                  ⅇ                  m                                                      -                          1                              1                +                                  ⅇ                  m                                                              =                      p            -            q                                              (        7        )            which will be referred to herein as “a posteriori probability difference”, or APPD. Note that the following expressions all represent the same information:APPD=p−q=tan h(m/2);LAPPD=(LAPPDsgn,LAPPDmag)=(sign(APPD),ln|APPD|);APPR=p/q; andLAPPR=m=ln p/q 
By substituting the expression for APPD of equation (7) into equation (5), APPD-based check node computation becomes:
                              APPD                      c            →            v                          =                              ∏                          h              ∈                                                n                  c                                -                                  {                  v                  }                                                              ⁢                                          ⁢                      APPD                          h              →              c                                                          (        8        )            Thus, the APPD as the output message of a check node is the product of the incoming APPD messages.
In conventional LDPC decoders, the messages that are passed back and forth between variable and check nodes are of the same form, namely all LAPPR, all APPR or all LAPPD.